package com.example.chengzhengwei;

import android.content.Intent;
import android.database.Cursor;
import android.graphics.Color;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.TextView;
import android.widget.Toast;

import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.core.content.ContextCompat;

import com.example.chengzhengwei.utils.SpectrophotometerProtocol;
import com.github.mikephil.charting.charts.LineChart;
import com.github.mikephil.charting.components.Legend;
import com.github.mikephil.charting.components.XAxis;
import com.github.mikephil.charting.components.YAxis;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.data.LineData;
import com.github.mikephil.charting.data.LineDataSet;
import com.github.mikephil.charting.formatter.ValueFormatter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

public class RunActivity extends AppCompatActivity {

    private LineChart chart;
    private List<LineDataSet> dataSets = new ArrayList<>();
    private Map<Integer, List<Entry>> channelDataMap = new HashMap<>();

    private Handler handler = new Handler(Looper.getMainLooper());
    private Runnable runnable;
    private TextView statusTextView;
    private Button stopButton, reportButton, exportButton, retryButton,btnallscreen;
    private CheckBox checkBox1, checkBox2, checkBox3, checkBox4, checkBox5, checkBox6, checkBox7, checkBox8;
    private DatabaseHelper dbHelper;
    private int dataPointCount = 0;
    private long startTime;
    // 任务结束时间（分钟、秒），从数据库获取
    private int endMinutes, endSeconds;
    // 已运行时间（毫秒）
    private long elapsedTime;

    // 通道颜色数组（与CheckBox索引严格对应）
    private final int[] CHANNEL_COLORS = {
            0xFF0000FF, // 通道1：蓝色
            0xFFFF00FF, // 通道2：粉色
            0xFF00FF00, // 通道3：绿色
            0xFFFFFF00, // 通道4：黄色
            0xFF00FFFF, // 通道5：青色
            0xFF000080, // 通道6：深蓝色
            0xFF800080, // 通道7：紫色
            0xFF808000  // 通道8：橄榄绿
    };
    //结果
    private TextView[] channelResultTextViews;
    //参数
    private TextView[] channelParamTextViews;


    private SerialApp mSerialApp;
    private SerialApp.SerialReadCallback mSerialReadCallback;
    private int mExpectedDataPoints; // 预期数据点数量
    private int mSamplePeriod; // 采样周期（秒）
    private int mTotalSeconds; // 总采样时间（秒）
    private int mReceivedDataPoints = 0; // 已接收数据点数量
    private boolean mExperimentStarted = false; // 实验是否已开始

    // 添加临时存储列表，使用 DatabaseHelper 中定义的 RunData 类
    private List<RunData> tempRunDataList = new ArrayList<>();

    private boolean isNormalizeEnabled = false; // 归一化状态

    private static final float THRESHOLD_A = 50000f; // 阳性阈值
    private static final float THRESHOLD_B = 30000f; // 弱阳性阈值


    private static final float NORMALIZATION_FACTOR = 10000.0f; // 归一化因子k
    private Map<Integer, Float> channelMinValues = new HashMap<>(); // 存储每个通道的最小值

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_run);

        // 设置Toolbar
        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);
        getSupportActionBar().setDisplayShowTitleEnabled(false); // 禁用默认标题

        // 启用返回按钮
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
        getSupportActionBar().setDisplayShowHomeEnabled(true);

        dbHelper = new DatabaseHelper(this);

        //初始化串口应用
        mSerialApp = (SerialApp) getApplication();

        // 初始化UI组件
        chart = findViewById(R.id.chart);
        statusTextView = findViewById(R.id.textViewStatus);
        stopButton = findViewById(R.id.buttonStop);
        reportButton = findViewById(R.id.buttonReport);
        exportButton = findViewById(R.id.buttonExport);
        retryButton = findViewById(R.id.buttonretry);



        checkBox1 = findViewById(R.id.checkBox1);
        checkBox2 = findViewById(R.id.checkBox2);
        checkBox3 = findViewById(R.id.checkBox3);
        checkBox4 = findViewById(R.id.checkBox4);
        checkBox5 = findViewById(R.id.checkBox5);
        checkBox6 = findViewById(R.id.checkBox6);
        checkBox7 = findViewById(R.id.checkBox7);
        checkBox8 = findViewById(R.id.checkBox8);

        // 初始化通道结果的 TextView 数组
        channelResultTextViews = new TextView[8];
        channelResultTextViews[0] = findViewById(R.id.tvChannel1Result);
        channelResultTextViews[1] = findViewById(R.id.tvChannel2Result);
        channelResultTextViews[2] = findViewById(R.id.tvChannel3Result);
        channelResultTextViews[3] = findViewById(R.id.tvChannel4Result);
        channelResultTextViews[4] = findViewById(R.id.tvChannel5Result);
        channelResultTextViews[5] = findViewById(R.id.tvChannel6Result);
        channelResultTextViews[6] = findViewById(R.id.tvChannel7Result);
        channelResultTextViews[7] = findViewById(R.id.tvChannel8Result);

        // 初始化通道结果的 TextView 数组
        channelParamTextViews = new TextView[8];
        channelParamTextViews[0] = findViewById(R.id.tvChannel1Param);
        channelParamTextViews[1] = findViewById(R.id.tvChannel2Param);
        channelParamTextViews[2] = findViewById(R.id.tvChannel3Param);
        channelParamTextViews[3] = findViewById(R.id.tvChannel4Param);
        channelParamTextViews[4] = findViewById(R.id.tvChannel5Param);
        channelParamTextViews[5] = findViewById(R.id.tvChannel6Param);
        channelParamTextViews[6] = findViewById(R.id.tvChannel7Param);
        channelParamTextViews[7] = findViewById(R.id.tvChannel8Param);


        for (int i = 0; i < 8; i++) {
            channelResultTextViews[i].setText("检测中");
            channelParamTextViews[i].setText("检测中");
        }

        // 从数据库加载任务结束时间
        loadEndTimeFromDB();
        // 设置CheckBox初始状态和颜色
        setupCheckBoxes();
        // 设置按钮事件
        setupButtonListeners();
        // 初始化图表
        initializeChart();
        // 开始数据采集


    }



    private void processSerialData(byte[] data) {
        try {
            SpectrophotometerProtocol.Response response =
                    SpectrophotometerProtocol.parseResponse(data);

            switch (response.getCommand()) {
                case SpectrophotometerProtocol.RESP_START_EXP:
                    if (response.isStartExperimentSuccessful()) {
                        runOnUiThread(() -> {
                            statusTextView.setText("状态：运行中");
                            Toast.makeText(this, "实验开始", Toast.LENGTH_SHORT).show();
                        });
                        mExperimentStarted = true;
                    }
                    break;

                case SpectrophotometerProtocol.RESP_AUTO_UPLOAD:
                    SpectrophotometerProtocol.TemperatureFluorData fluorData =
                            response.getTemperatureFluorData();

                    runOnUiThread(() -> {
                        // 更新图表和数据库
                        processFluorData(fluorData);
                        mReceivedDataPoints++;

                        // 检查是否完成
//                        if (mReceivedDataPoints >= mExpectedDataPoints) {
//                            stopRunning();
//                        }
                    });
                    break;

                case SpectrophotometerProtocol.RESP_EXP_END:
                    mExperimentStarted = false;

                    runOnUiThread(() -> {
                        stopRunning();
                        Toast.makeText(this, "实验结束", Toast.LENGTH_SHORT).show();
                    });
                    break;
            }
        } catch (SpectrophotometerProtocol.ProtocolException e) {
            Log.e("RunActivity", "协议解析错误", e);
        }
    }

    private void processFluorData(SpectrophotometerProtocol.TemperatureFluorData fluorData) {
        long currentTime = System.currentTimeMillis();
        dataPointCount++;

        // 计算当前时间（分钟和秒）
        long elapsedSeconds = (currentTime - startTime) / 1000;
        int minutes = (int) (elapsedSeconds / 60);
        int seconds = (int) (elapsedSeconds % 60);

        // 获取温度（转换为摄氏度）
        float temperature = (float) fluorData.getActualTemperature();

        // 处理8个通道的数据
        for (int i = 0; i < 8; i++) {
            float value = fluorData.getFluorValue(i + 1); // 通道索引从1开始
            List<Entry> entries = channelDataMap.get(i);
            // 更新图表czw
//            if(true)
//            {
                entries.add(new Entry(dataPointCount, value));
//            }
//                else
//            {
//                entries.add(new Entry(dataPointCount, value));
//            }

            dataSets.get(i).setValues(entries);

            // 创建 RunData 对象并添加到临时列表（使用 DatabaseHelper 中的 RunData 类）
            RunData runData = new RunData(
                    0, // id 由数据库自动生成，这里设为0
                    i, // channel
                    value, // value
                    currentTime, // timestamp
                    minutes, // minutes
                    seconds, // seconds
                    temperature, // temperature
                    dataPointCount // generationCount
            );

            tempRunDataList.add(runData);
        }

        // 更新X轴标签
        updateXAxisLabelCount();
        // 刷新图表
        chart.getData().notifyDataChanged();
        chart.notifyDataSetChanged();
        chart.invalidate();
    }

    private void loadEndTimeFromDB() {
        Cursor cursor = dbHelper.getAllData();
        if (cursor != null && cursor.moveToFirst()) {
            int timeMinutesIndex = cursor.getColumnIndex(DatabaseHelper.COLUMN_TIME_MINUTES);
            int timeSecondsIndex = cursor.getColumnIndex(DatabaseHelper.COLUMN_TIME_SECONDS);
            int periodIndex = cursor.getColumnIndex(DatabaseHelper.COLUMN_FLUORESCENCE_PERIOD);
            if (periodIndex != -1) {
                mSamplePeriod = cursor.getInt(periodIndex);
            }else{
                mSamplePeriod=30;
            }
            if (timeMinutesIndex != -1 && timeSecondsIndex != -1) {
                endMinutes = cursor.getInt(timeMinutesIndex);
                endSeconds = cursor.getInt(timeSecondsIndex);
            } else {
                // 如果数据库中无有效数据，设置默认结束时间（这里设为10分钟0秒）
                endMinutes = 10;
                endSeconds = 0;
            }
            cursor.close();
        } else {
            // 无数据时设置默认结束时间
            endMinutes = 10;
            endSeconds = 0;
            mSamplePeriod=30;
        }

        // 计算预期数据点
        mTotalSeconds = endMinutes * 60 + endSeconds;
        // 从数据库获取采样周期（假设已保存）
        mExpectedDataPoints = (mTotalSeconds / mSamplePeriod) + 1;
    }

    private void setupCheckBoxes() {
        // 为每个CheckBox设置初始状态和颜色
        for (int i = 0; i < 8; i++) {
            CheckBox cb = getCheckBox(i);
            cb.setChecked(true); // 默认全部选中

            // 设置CheckBox的颜色与对应通道一致
            int color = CHANNEL_COLORS[i];
            cb.setTextColor(color);

            // 为API 21+设置按钮颜色
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
                cb.setButtonTintList(ContextCompat.getColorStateList(this,
                        getColorResourceForColor(color)));
            }

            // 设置CheckBox点击事件
            final int channelIndex = i;
            cb.setOnClickListener(v -> updateChannelVisibility(channelIndex));
        }
    }

    private void setupButtonListeners() {
        stopButton.setOnClickListener(v -> showStopConfirmationDialog());
        reportButton.setOnClickListener(v -> Toast.makeText(this, "报告已生成", Toast.LENGTH_SHORT).show());
        exportButton.setOnClickListener(v -> {
            Intent intent = new Intent(RunActivity.this, ExportOptionsActivity.class);
            startActivity(intent);
        });
        retryButton.setOnClickListener(v -> {
            resetTimerAndChart();
            resetTable();
            startRunning();
        });

    }

    private void showFullScreenChart() {
        if (tempRunDataList == null || tempRunDataList.isEmpty()) {
            Toast.makeText(this, "没有可用数据", Toast.LENGTH_SHORT).show();
            return;
        }

        Intent intent = new Intent(this, FullScreenRunActivity.class);
        // 传递数据
        intent.putExtra("runDataList", new ArrayList<>(tempRunDataList)); // 创建副本避免并发问题
        intent.putExtra("samplePeriod", mExpectedDataPoints);
        startActivity(intent);
    }


    private void updateChannelVisibility(int channelIndex) {
        CheckBox cb = getCheckBox(channelIndex);
        LineDataSet dataSet = dataSets.get(channelIndex);

        // 根据CheckBox状态设置数据集可见性
        dataSet.setVisible(cb.isChecked());

        // 刷新图表
        chart.getData().notifyDataChanged();
        chart.notifyDataSetChanged();
        chart.invalidate();
    }

    private void initializeChart() {
        // 创建并配置图表
        chart.getDescription().setEnabled(false); // 禁用默认描述

        // 初始化每个通道的数据集
        for (int i = 0; i < 8; i++) {
            LineDataSet dataSet = new LineDataSet(new ArrayList<>(), "通道" + (i + 1));
            dataSet.setColor(CHANNEL_COLORS[i]);
            dataSet.setLineWidth(2f);
            dataSet.setDrawCircles(true);
            dataSet.setDrawValues(false);
            dataSet.setVisible(true); // 默认可见，由CheckBox控制

            dataSets.add(dataSet);
            channelDataMap.put(i, new ArrayList<>());
        }

        // 设置图表数据
        LineData lineData = new LineData();
        for (LineDataSet dataSet : dataSets) {
            lineData.addDataSet(dataSet);
        }
        chart.setData(lineData);

        // 禁用右侧图例（通过CheckBox显示颜色）
        Legend legend = chart.getLegend();
        legend.setEnabled(false);

        // 配置X轴（时间轴）
        XAxis xAxis = chart.getXAxis();
        xAxis.setPosition(XAxis.XAxisPosition.BOTTOM);
        xAxis.setGranularity(1f);
        xAxis.setDrawGridLines(true);

        // 设置X轴标签为时间格式（分钟:秒）
        xAxis.setValueFormatter(new ValueFormatter() {
            @Override
            public String getFormattedValue(float value) {
                int seconds = (int) (value * mSamplePeriod); // 每个数据点间隔mSamplePeriod秒
                if (seconds < 60) {
                    return seconds + "s";
                } else {
                    int mins = seconds / 60;
                    int secs = seconds % 60;
                    return String.format("%d:%02d", mins, secs);
                }
            }
        });

        // 配置Y轴（荧光强度）
        YAxis leftAxis = chart.getAxisLeft();
        leftAxis.setAxisMinimum(0f);
        leftAxis.setAxisMaximum(160000f); // 设置固定范围，避免数据超出
        leftAxis.setDrawGridLines(true);
        leftAxis.setValueFormatter(new ValueFormatter() {
            @Override
            public String getFormattedValue(float value) {
                return String.format("%.0f", value);
            }
        });

        // 禁用右侧Y轴
        YAxis rightAxis = chart.getAxisRight();
        rightAxis.setEnabled(false);

        chart.invalidate(); // 刷新图表
    }

    private void startRunning() {
        // 清空之前的数据
        dbHelper.clearRunData();
        mReceivedDataPoints = 0;
        dataPointCount = 0;

        registerRecycleReading();

        // 发送开始命令
        byte[] startCommand = SpectrophotometerProtocol.buildStartExperimentCommand(
                SpectrophotometerProtocol.PC_ADDRESS
        );

        mSerialApp.safeWrite(startCommand, new SerialApp.SerialWriteCallback() {
            @Override
            public void onWriteComplete(int bytesWritten) {
                // 开始循环读取数据
                // mSerialApp.recycleReading(mSerialReadCallback);
            }

            @Override
            public void onWriteError(Exception e) {
                runOnUiThread(() -> {
                    Toast.makeText(RunActivity.this, "发送开始命令失败", Toast.LENGTH_SHORT).show();
                    statusTextView.setText("状态：发送失败");
                });
            }
        });

        // 更新UI
        statusTextView.setText("状态：启动中...");
        stopButton.setEnabled(true);
        reportButton.setEnabled(false);
        exportButton.setEnabled(false);
        retryButton.setEnabled(false);
    }

    /**
     * 显示停止实验确认对话框
     * 旧弹窗
     */
//    private void showStopConfirmationDialog() {
//        android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(this);
//        builder.setTitle("确认停止实验");
//        builder.setMessage("确定要停止当前实验吗？停止后将无法恢复正在采集的数据。");
//        builder.setPositiveButton("确认", (dialog, which) -> {
//            // 确认停止，执行原有停止逻辑
//            stopRunning();
//        });
//        builder.setNegativeButton("取消", (dialog, which) -> {
//            // 取消停止，不执行任何操作
//            Toast.makeText(this, "已取消停止操作", Toast.LENGTH_SHORT).show();
//        });
//        builder.create().show();
//    }


    private void showStopConfirmationDialog() {
        // 使用自定义布局创建对话框
        View dialogView = LayoutInflater.from(this).inflate(R.layout.dialog_custom_confirm, null);

        android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(this);
        builder.setTitle("确认停止实验");
        builder.setMessage("确定要停止当前实验吗？停止后将无法恢复正在采集的数据。");
        builder.setView(dialogView); // 设置自定义布局

        final android.app.AlertDialog dialog = builder.create();

        // 获取自定义布局中的按钮
        Button btnConfirm = dialogView.findViewById(R.id.btn_confirm);
        Button btnCancel = dialogView.findViewById(R.id.btn_cancel);

        // 设置按钮点击事件
        btnConfirm.setOnClickListener(v -> {
            //stopRunning();
            abortExperiment();
            dialog.dismiss();
        });

        btnCancel.setOnClickListener(v -> {
            Toast.makeText(this, "已取消停止操作", Toast.LENGTH_SHORT).show();
            dialog.dismiss();
        });

        dialog.show();
    }

    private void stopRunning() {
//

        // 更新UI
        statusTextView.setText("状态：运行完成");
        stopButton.setEnabled(false);
        reportButton.setEnabled(true);
        exportButton.setEnabled(true);
        retryButton.setEnabled(true);

        //将接受到的数据保存到数据库
        saveAllDataToDatabase();

        // 计算结果
        for (int i = 0; i < 8; i++) {
            // 获取该通道最后一次的值
            float value = getLastChannelValue(i);
            String result = calculateResult(i);
            channelResultTextViews[i].setText(result);
            channelParamTextViews[i].setText(String.format("%.0f", value));
        }
        // 如果归一化已启用，重新应用归一化以刷新图表
        if (isNormalizeEnabled) {
            applyNormalization(true);
        }
        //Toast.makeText(this, "实验已停止", Toast.LENGTH_SHORT).show();
    }

    //重置列表为初始值
    private void resetTable(){
        for (int i = 0; i < 8; i++) {
            // 获取该通道最后一次的值
            String result = "检测中";
            channelResultTextViews[i].setText(result);
            channelParamTextViews[i].setText(result);
        }
    }

    private void abortExperiment(){
        if (mExperimentStarted) {
            // 发送停止命令
            byte[] stopCommand = SpectrophotometerProtocol.buildStopExperimentCommand(
                    SpectrophotometerProtocol.DEVICE_ADDRESS
            );
            mSerialApp.safeWrite(stopCommand, new SerialApp.SerialWriteCallback() {
                @Override
                public void onWriteComplete(int bytesWritten) {

                }
                @Override
                public void onWriteError(Exception e) {
                    runOnUiThread(() -> {
                        Toast.makeText(RunActivity.this, "发送结束实验命令失败", Toast.LENGTH_SHORT).show();
                        //statusTextView.setText("状态：发送失败");
                    });
                }
            });
            //unregisterRecycleReading();
        }
    }


    private void saveAllDataToDatabase() {
        for (RunData runData : tempRunDataList) {
            dbHelper.saveRunData(
                    runData.getChannel(),
                    runData.getValue(),
                    runData.getTimestamp(),
                    runData.getMinutes(),
                    runData.getSeconds(),
                    runData.getTemperature(),
                    runData.getGenerationCount()
            );
        }

    }

    // 固定算法，这里简单返回 "阳性"，你可以根据实际需求修改
    private String calculateResult(float value) {


        // 根据阈值判断结果
        if (value >= THRESHOLD_A) {
            return "阳性";
        } else if (value >= THRESHOLD_B && value < THRESHOLD_A) {
            return "弱阳性";
        } else {
            return "阴性";
        }
    }

    /**
     * 重置计时器和图表数据
     */
    private void resetTimerAndChart() {
        // 丢弃数据
        tempRunDataList.clear();
        // 清空图表数据
        clearChartData();
        // 重置计时变量
        startTime = System.currentTimeMillis();
        elapsedTime = 0;
        dataPointCount = 0;

        // 更新状态文本
        statusTextView.setText("状态：运行中");
    }

    /**
     * 清空折线图所有数据，恢复初始状态
     */
    private void clearChartData() {
        // 1. 清空每个通道的数据集
        for (int i = 0; i < 8; i++) {
            List<Entry> entries = channelDataMap.get(i);
            entries.clear(); // 清空当前通道数据

            // 更新LineDataSet中的数据
            LineDataSet dataSet = dataSets.get(i);
            dataSet.setValues(entries);
        }

        // 2. 重置数据点计数
        dataPointCount = 0;

        // 3. 刷新X轴标签
        updateXAxisLabelCount();

        // 4. 通知图表数据已更改并刷新显示
        chart.getData().notifyDataChanged();
        chart.notifyDataSetChanged();
        chart.invalidate();


    }

//    private void generateData() {
//        Random random = new Random();
//        dataPointCount++;
//        // 生成温度（0 - 100 度）
//        float temperature = random.nextFloat() * 100;
//
//        // 计算当前时间点（分钟和秒）
//        long elapsedTime = System.currentTimeMillis() - startTime;
//        long elapsedSeconds = elapsedTime / 1000;
//        int minutes = (int) (elapsedSeconds / 60);
//        int seconds = (int) (elapsedSeconds % 60);
//        // 为所有通道生成数据（无论是否可见）
//        for (int i = 0; i < 8; i++) {
//            double value = 58000 + random.nextDouble() * (145000 - 58000);
//            List<Entry> entries = channelDataMap.get(i);
//            entries.add(new Entry(dataPointCount, (float) value));
//
//            // 更新数据集
//            dataSets.get(i).setValues(entries);
//
//            // 保存到数据库
//            dbHelper.saveRunData(i, (float) value, System.currentTimeMillis(), minutes, seconds, temperature, dataPointCount);
//        }
//        // 更新X轴标签
//        updateXAxisLabelCount();
//        // 刷新图表
//        chart.getData().notifyDataChanged();
//        chart.notifyDataSetChanged();
//        chart.invalidate();
//    }

    private void updateXAxisLabelCount() {
        // 根据数据点数量动态调整X轴标签数量
        XAxis xAxis = chart.getXAxis();
        xAxis.setLabelCount(Math.min(dataPointCount, 8), false);
    }

    private CheckBox getCheckBox(int index) {
        switch (index) {
            case 0:
                return checkBox1;
            case 1:
                return checkBox2;
            case 2:
                return checkBox3;
            case 3:
                return checkBox4;
            case 4:
                return checkBox5;
            case 5:
                return checkBox6;
            case 6:
                return checkBox7;
            case 7:
                return checkBox8;
            default:
                return null;
        }
    }

    // 根据颜色值获取对应的资源ID（需要在colors.xml中定义）
    private int getColorResourceForColor(int color) {
        switch (color) {
            case 0xFF0000FF:
                return R.color.channel1;
            case 0xFFFF00FF:
                return R.color.channel2;
            case 0xFF00FF00:
                return R.color.channel3;
            case 0xFFFFFF00:
                return R.color.channel4;
            case 0xFF00FFFF:
                return R.color.channel5;
            case 0xFF000080:
                return R.color.channel6;
            case 0xFF800080:
                return R.color.channel7;
            case 0xFF808000:
                return R.color.channel8;
            default:
                return android.R.color.holo_blue_dark;
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 设置串口数据接收回调
        registerRecycleReading();

        // 自动开始实验
        if (!mExperimentStarted) {
            startRunning();
        }
    }

    @Override
    protected void onPause() {
        super.onPause();

    }

    @Override
    protected void onStop() {
        super.onStop();
        // 取消注册回调
        unregisterRecycleReading();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
    }

    /**
     * 获取指定通道的所有数据值
     * @param channel 通道编号 (1-8)
     * @return 包含该通道所有数据值的列表
     */
    public List<Float> getChannelValues(int channel) {
        List<Float> values = new ArrayList<>();

        // 参数范围检测
        if (channel < 1 || channel > 8) {
            // 记录错误日志并返回空列表
            Log.e("RunActivity", "无效的通道参数: " + channel + "。通道值必须在1-8范围内。");
            return values;
        }

        // 将通道号转换为内部索引 (1-8 -> 0-7)
        int channelIndex = channel - 1;

        if (tempRunDataList == null || tempRunDataList.size() == 0){
            Log.e("RunActivity", "tempRunDataList 为空!");
            return values;
        }

        // 遍历临时数据列表
        for (RunData runData : tempRunDataList) {
            if (runData.getChannel() == channelIndex) {
                values.add(runData.getValue());
            }
        }
        return values;
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_run_activity, menu);

        // 获取归一化菜单项并设置初始状态
        MenuItem normalizeItem = menu.findItem(R.id.menu_normalize);
        normalizeItem.setChecked(isNormalizeEnabled);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        int id = item.getItemId();

        // 处理返回按钮点击
        if (id == android.R.id.home) {
            //onBackPressed(); // 调用返回方法
//            if(stopButton.isEnabled()){
//                abortExperiment();
//                finish();
//            }
            if(mExperimentStarted){
                Toast.makeText(mSerialApp, "正在进行中，终止后再退出", Toast.LENGTH_SHORT).show();
                return true;
            }
            finish();
            return true;
        } else if (id == R.id.menu_fullscreen) {
            showFullScreenChart();
            return true;
        } else if (id == R.id.menu_normalize) {
            // 切换归一化状态
            isNormalizeEnabled = !item.isChecked();
            item.setChecked(isNormalizeEnabled);

            // 应用归一化设置
            applyNormalization(isNormalizeEnabled);
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    //归一化算法，写到这里
    private void applyNormalization(boolean enabled) {
        if (enabled) {
            // 计算每个通道的最小值
            calculateChannelMinValues();
            // 创建归一化后的数据列表
            List<RunData> normalizedData = normalizeData();

            // 使用归一化数据更新图表
            updateChartWithNormalizedData(normalizedData);

            Toast.makeText(this, "归一化已启用", Toast.LENGTH_SHORT).show();
        } else {
            // 使用原始数据更新图表
            updateChartWithOriginalData();

            Toast.makeText(this, "归一化已禁用", Toast.LENGTH_SHORT).show();
        }
    }

    @Override
    public void onBackPressed() {
        // 显示确认对话框
        super.onBackPressed();
        // 使用自定义布局创建对话框
        View dialogView = LayoutInflater.from(this).inflate(R.layout.dialog_custom_confirm, null);
        android.app.AlertDialog.Builder builder = new android.app.AlertDialog.Builder(this);
        builder.setTitle("确认退出");
        builder.setMessage("确定要退出检测界面吗");
        builder.setView(dialogView); // 设置自定义布局

        final android.app.AlertDialog dialog = builder.create();

        // 获取自定义布局中的按钮
        Button btnConfirm = dialogView.findViewById(R.id.btn_confirm);
        Button btnCancel = dialogView.findViewById(R.id.btn_cancel);

        // 设置按钮点击事件
        btnConfirm.setOnClickListener(v -> {
            if (stopButton.isEnabled()) {
                abortExperiment();
            }
            // 关闭当前Activity
            finish();
        });

        btnCancel.setOnClickListener(v -> {
            Toast.makeText(this, "已取消停止操作", Toast.LENGTH_SHORT).show();
            dialog.dismiss();
        });
        dialog.show();
    }

    // 获取通道最后一次的值
    private float getLastChannelValue(int channelIndex) {
        float lastValue = 0f;
        // 遍历临时数据列表，找到该通道的最后一个值
        for (int i = tempRunDataList.size() - 1; i >= 0; i--) {
            RunData data = tempRunDataList.get(i);
            if (data.getChannel() == channelIndex) {
                lastValue = data.getValue();
                break;
            }
        }
        return lastValue;
    }


    /**
    * 计算每个通道的最小值并存储在channelMinValues中
     */
    private void calculateChannelMinValues() {
        channelMinValues.clear();

        // 初始化每个通道的最小值为最大值
        for (int i = 0; i < 8; i++) {
            channelMinValues.put(i, Float.MAX_VALUE);
        }

        // 遍历所有数据，找到每个通道的最小值
        for (RunData data : tempRunDataList) {
            int channel = data.getChannel();
            float value = data.getValue();

            // 更新最小值
            if (value < channelMinValues.get(channel)) {
                channelMinValues.put(channel, value);
            }
        }
    }

    /**
     * 创建归一化后的数据列表
     */
    private List<RunData> normalizeData() {
        List<RunData> normalizedList = new ArrayList<>();

        for (RunData data : tempRunDataList) {
            int channel = data.getChannel();
            float minValue = channelMinValues.get(channel);

            // 避免除以0
            if (minValue == 0) {
                minValue = 1.0f; // 防止除以0
            }

            // 归一化计算: (value / minValue) * NORMALIZATION_FACTOR
            float normalizedValue = (data.getValue() / minValue) * NORMALIZATION_FACTOR;

            // 创建新的RunData对象，其他字段保持不变
            RunData normalizedData = new RunData(
                    data.getId(),
                    channel,
                    normalizedValue,
                    data.getTimestamp(),
                    data.getMinutes(),
                    data.getSeconds(),
                    data.getTemperature(),
                    data.getGenerationCount()
            );

            normalizedList.add(normalizedData);
        }

        return normalizedList;
    }

    /**
     * 使用归一化数据更新图表
     */
    private void updateChartWithNormalizedData(List<RunData> normalizedData) {
        // 清空当前图表数据
        for (int i = 0; i < 8; i++) {
            channelDataMap.get(i).clear();
        }

        // 填充归一化数据
        for (RunData data : normalizedData) {
            int channel = data.getChannel();
            float value = data.getValue();
            int generationCount = data.getGenerationCount();

            if (channel >= 0 && channel < 8) {
                List<Entry> entries = channelDataMap.get(channel);
                entries.add(new Entry(generationCount, value));
                dataSets.get(channel).setValues(entries);
            }
        }

        // 调整Y轴范围以适应归一化数据
        adjustYAxisForNormalizedData();

        // 刷新图表
        refreshChart();
    }

    /**
     * 使用原始数据更新图表
     */
    private void updateChartWithOriginalData() {
        // 清空当前图表数据
        for (int i = 0; i < 8; i++) {
            channelDataMap.get(i).clear();
        }

        // 填充原始数据
        for (RunData data : tempRunDataList) {
            int channel = data.getChannel();
            float value = data.getValue();
            int generationCount = data.getGenerationCount();

            if (channel >= 0 && channel < 8) {
                List<Entry> entries = channelDataMap.get(channel);
                entries.add(new Entry(generationCount, value));
                dataSets.get(channel).setValues(entries);
            }
        }

        // 恢复原始Y轴范围
        resetYAxisToOriginal();

        // 刷新图表
        refreshChart();
    }

    /**
     * 调整Y轴范围以适应归一化数据
     */
    private void adjustYAxisForNormalizedData() {
        YAxis leftAxis = chart.getAxisLeft();

        // 找到归一化后的最大值
        float maxValue = 0;
        for (int i = 0; i < 8; i++) {
            for (Entry entry : channelDataMap.get(i)) {
                if (entry.getY() > maxValue) {
                    maxValue = entry.getY();
                }
            }
        }

        // 设置合适的Y轴范围
        leftAxis.setAxisMaximum(maxValue * 1.2f); // 增加20%的余量
        leftAxis.setAxisMinimum(0);
    }

    /**
     * 恢复原始Y轴范围
     */
    private void resetYAxisToOriginal() {
        YAxis leftAxis = chart.getAxisLeft();
        leftAxis.setAxisMaximum(160000f);
        leftAxis.setAxisMinimum(0);
    }

    /**
     * 刷新图表显示
     */
    private void refreshChart() {
        chart.getData().notifyDataChanged();
        chart.notifyDataSetChanged();
        chart.invalidate();
    }

    private void unregisterRecycleReading(){
        if (mSerialReadCallback != null) {
            //mSerialApp.unregisterRecycleReading(mSerialReadCallback);
            mSerialReadCallback = null;
        }
    }

    private void registerRecycleReading(){
        if(mSerialReadCallback==null){
            mSerialReadCallback = new SerialApp.SerialReadCallback() {
                @Override
                public void onDataReceived(byte[] data) {
                    processSerialData(data);
                }

                @Override
                public void onReadError(Exception e) {
                    runOnUiThread(() -> {
                        Toast.makeText(RunActivity.this, "串口读取错误: " + e.getMessage(), Toast.LENGTH_SHORT).show();
                        statusTextView.setText("状态：串口错误");
                    });
                }
            };
        }
        // 注册回调
        //mSerialApp.recycleReading(mSerialReadCallback);
    }

}